<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <script>
      const arr = [1, 2, 3, 4, 5]
      const obj = { name: 'zs', age: 18, sex: '男' }

      // for (const [k, v] of Object.entries(obj)) {
      //   console.log(k, v)
      // }

      // for (const v of Object.values(obj)) {
      //   console.log(v)
      // }

      // 下面的代码相当于：for ( const k of ['name', 'age', 'sex'] ) {}
      // for (const k of Object.keys(obj)) {
      //   console.log(k, obj[k])
      // }

      // Object.values(obj) 可以获取到这个对象中 所有 键值对 中的 值 组成的 数组
      // console.log(Object.values(obj), 'Object.values(obj)')

      // Object.keys(obj) 可以获取到这个对象中 所有 键值对 中的 键 组成的 数组
      // console.log(Object.keys(obj), 'Object.keys(obj)')

      // Object.entries(obj) 可以获取到这个对象中 所有 键值对 组成的 数组
      // console.log(Object.entries(obj), 'Object.entries(obj)')

      // 普通对象不是一个可迭代对象，所以以下语法会报错：Uncaught TypeError: obj is not iterable
      // for (const v of obj) {
      //   console.log(v)
      // }

      // 以后不管是遍历数组还是对象还是jq对象通通用 for ... of

      // for ... in 会遍历到对象的原型链上去
      // for (const k in obj) {
      //   console.log(k, obj[k])
      // }

      // 最普通循环语法
      // for (let i = 0; i < arr.length; i ++) {
      // console.log(i, arr[i])
      // }

      // 循环数组，索引和值都拿
      // for (const [i, v] of arr.entries()) {
      //   console.log(i, v) // 怎么拿索引
      // }

      // 循环数组，只拿索引
      // for (const i of arr.keys()) {
      //   console.log(i)
      // }

      // 循环数组，只拿值（arr.values()）
      // for (const v of arr) {
      //   console.log(v)
      // }

      // // 所谓块级作用域，就是一对花括号（不是对象的左右花括号）
      // {
      //   let a = 1
      //   console.log(a, 'a')
      // }
      // console.log(a)
    </script>
  </body>
</html>
